{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c9332348",
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 1\n",
    "%aimport experiment\n",
    "%aimport utils\n",
    "%aimport models.xai_models\n",
    "%aimport helper\n",
    "%aimport dataloader\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import pickle\n",
    "from sklearn.metrics import roc_auc_score, roc_curve\n",
    "\n",
    "import utils\n",
    "import ecg_processing\n",
    "from models.inception1d import Inception1d\n",
    "from models.xai_models import *\n",
    "import helper\n",
    "from dataloader import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "051c7468",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b32ab853",
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment_id = '20250602_01_inception_manual'\n",
    "output_folder = '../myoutput/'\n",
    "task = 'superdiagnostic'\n",
    "preprocessor_code = 'basic'\n",
    "task_type = 'multilabel'\n",
    "num_classes = 5\n",
    "sampling_freq = 100\n",
    "signal_length = 1000\n",
    "batch_size = 32\n",
    "num_epochs = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e7e03f2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inception1d(\n",
      "  (layers): Sequential(\n",
      "    (0): InceptionBackbone(\n",
      "      (im): ModuleList(\n",
      "        (0): InceptionBlock1d(\n",
      "          (bottleneck): Conv1d(12, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          (convs): ModuleList(\n",
      "            (0): Conv1d(32, 32, kernel_size=(39,), stride=(1,), padding=(19,), bias=False)\n",
      "            (1): Conv1d(32, 32, kernel_size=(19,), stride=(1,), padding=(9,), bias=False)\n",
      "            (2): Conv1d(32, 32, kernel_size=(9,), stride=(1,), padding=(4,), bias=False)\n",
      "          )\n",
      "          (conv_bottle): Sequential(\n",
      "            (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "            (1): Conv1d(12, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          )\n",
      "          (bn_relu): Sequential(\n",
      "            (0): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "            (1): ReLU()\n",
      "          )\n",
      "        )\n",
      "        (1-5): 5 x InceptionBlock1d(\n",
      "          (bottleneck): Conv1d(128, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          (convs): ModuleList(\n",
      "            (0): Conv1d(32, 32, kernel_size=(39,), stride=(1,), padding=(19,), bias=False)\n",
      "            (1): Conv1d(32, 32, kernel_size=(19,), stride=(1,), padding=(9,), bias=False)\n",
      "            (2): Conv1d(32, 32, kernel_size=(9,), stride=(1,), padding=(4,), bias=False)\n",
      "          )\n",
      "          (conv_bottle): Sequential(\n",
      "            (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "            (1): Conv1d(128, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          )\n",
      "          (bn_relu): Sequential(\n",
      "            (0): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "            (1): ReLU()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "      (sk): ModuleList(\n",
      "        (0): Shortcut1d(\n",
      "          (act_fn): ReLU(inplace=True)\n",
      "          (conv): Conv1d(12, 128, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          (bn): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "        (1): Shortcut1d(\n",
      "          (act_fn): ReLU(inplace=True)\n",
      "          (conv): Conv1d(128, 128, kernel_size=(1,), stride=(1,), bias=False)\n",
      "          (bn): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (1): Sequential(\n",
      "      (0): AdaptiveConcatPool1d(\n",
      "        (ap): AdaptiveAvgPool1d(output_size=1)\n",
      "        (mp): AdaptiveMaxPool1d(output_size=1)\n",
      "      )\n",
      "      (1): Flatten()\n",
      "      (2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (3): Dropout(p=0.25, inplace=False)\n",
      "      (4): Linear(in_features=256, out_features=128, bias=True)\n",
      "      (5): ReLU(inplace=True)\n",
      "      (6): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (7): Dropout(p=0.5, inplace=False)\n",
      "      (8): Linear(in_features=128, out_features=5, bias=True)\n",
      "    )\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Initialize the model and load the trained weights\n",
    "model = Inception1d(\n",
    "\tnum_classes=num_classes,\n",
    "\tinput_channels=12,\n",
    "\tuse_residual=True,\n",
    "\tps_head=0.5,\n",
    "\tlin_ftrs_head=[128],\n",
    "\tkernel_size=40\n",
    "\t)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fb79cca0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1             [-1, 32, 1000]             384\n",
      "            Conv1d-2             [-1, 32, 1000]          39,936\n",
      "            Conv1d-3             [-1, 32, 1000]          19,456\n",
      "            Conv1d-4             [-1, 32, 1000]           9,216\n",
      "         MaxPool1d-5             [-1, 12, 1000]               0\n",
      "            Conv1d-6             [-1, 32, 1000]             384\n",
      "       BatchNorm1d-7            [-1, 128, 1000]             256\n",
      "              ReLU-8            [-1, 128, 1000]               0\n",
      "  InceptionBlock1d-9            [-1, 128, 1000]               0\n",
      "           Conv1d-10             [-1, 32, 1000]           4,096\n",
      "           Conv1d-11             [-1, 32, 1000]          39,936\n",
      "           Conv1d-12             [-1, 32, 1000]          19,456\n",
      "           Conv1d-13             [-1, 32, 1000]           9,216\n",
      "        MaxPool1d-14            [-1, 128, 1000]               0\n",
      "           Conv1d-15             [-1, 32, 1000]           4,096\n",
      "      BatchNorm1d-16            [-1, 128, 1000]             256\n",
      "             ReLU-17            [-1, 128, 1000]               0\n",
      " InceptionBlock1d-18            [-1, 128, 1000]               0\n",
      "           Conv1d-19             [-1, 32, 1000]           4,096\n",
      "           Conv1d-20             [-1, 32, 1000]          39,936\n",
      "           Conv1d-21             [-1, 32, 1000]          19,456\n",
      "           Conv1d-22             [-1, 32, 1000]           9,216\n",
      "        MaxPool1d-23            [-1, 128, 1000]               0\n",
      "           Conv1d-24             [-1, 32, 1000]           4,096\n",
      "      BatchNorm1d-25            [-1, 128, 1000]             256\n",
      "             ReLU-26            [-1, 128, 1000]               0\n",
      " InceptionBlock1d-27            [-1, 128, 1000]               0\n",
      "           Conv1d-28            [-1, 128, 1000]           1,536\n",
      "      BatchNorm1d-29            [-1, 128, 1000]             256\n",
      "             ReLU-30            [-1, 128, 1000]               0\n",
      "       Shortcut1d-31            [-1, 128, 1000]               0\n",
      "           Conv1d-32             [-1, 32, 1000]           4,096\n",
      "           Conv1d-33             [-1, 32, 1000]          39,936\n",
      "           Conv1d-34             [-1, 32, 1000]          19,456\n",
      "           Conv1d-35             [-1, 32, 1000]           9,216\n",
      "        MaxPool1d-36            [-1, 128, 1000]               0\n",
      "           Conv1d-37             [-1, 32, 1000]           4,096\n",
      "      BatchNorm1d-38            [-1, 128, 1000]             256\n",
      "             ReLU-39            [-1, 128, 1000]               0\n",
      " InceptionBlock1d-40            [-1, 128, 1000]               0\n",
      "           Conv1d-41             [-1, 32, 1000]           4,096\n",
      "           Conv1d-42             [-1, 32, 1000]          39,936\n",
      "           Conv1d-43             [-1, 32, 1000]          19,456\n",
      "           Conv1d-44             [-1, 32, 1000]           9,216\n",
      "        MaxPool1d-45            [-1, 128, 1000]               0\n",
      "           Conv1d-46             [-1, 32, 1000]           4,096\n",
      "      BatchNorm1d-47            [-1, 128, 1000]             256\n",
      "             ReLU-48            [-1, 128, 1000]               0\n",
      " InceptionBlock1d-49            [-1, 128, 1000]               0\n",
      "           Conv1d-50             [-1, 32, 1000]           4,096\n",
      "           Conv1d-51             [-1, 32, 1000]          39,936\n",
      "           Conv1d-52             [-1, 32, 1000]          19,456\n",
      "           Conv1d-53             [-1, 32, 1000]           9,216\n",
      "        MaxPool1d-54            [-1, 128, 1000]               0\n",
      "           Conv1d-55             [-1, 32, 1000]           4,096\n",
      "      BatchNorm1d-56            [-1, 128, 1000]             256\n",
      "             ReLU-57            [-1, 128, 1000]               0\n",
      " InceptionBlock1d-58            [-1, 128, 1000]               0\n",
      "           Conv1d-59            [-1, 128, 1000]          16,384\n",
      "      BatchNorm1d-60            [-1, 128, 1000]             256\n",
      "             ReLU-61            [-1, 128, 1000]               0\n",
      "       Shortcut1d-62            [-1, 128, 1000]               0\n",
      "InceptionBackbone-63            [-1, 128, 1000]               0\n",
      "AdaptiveMaxPool1d-64               [-1, 128, 1]               0\n",
      "AdaptiveAvgPool1d-65               [-1, 128, 1]               0\n",
      "AdaptiveConcatPool1d-66               [-1, 256, 1]               0\n",
      "          Flatten-67                  [-1, 256]               0\n",
      "      BatchNorm1d-68                  [-1, 256]             512\n",
      "          Dropout-69                  [-1, 256]               0\n",
      "           Linear-70                  [-1, 128]          32,896\n",
      "             ReLU-71                  [-1, 128]               0\n",
      "      BatchNorm1d-72                  [-1, 128]             256\n",
      "          Dropout-73                  [-1, 128]               0\n",
      "           Linear-74                    [-1, 5]             645\n",
      "================================================================\n",
      "Total params: 507,653\n",
      "Trainable params: 507,653\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.05\n",
      "Forward/backward pass size (MB): 38.68\n",
      "Params size (MB): 1.94\n",
      "Estimated Total Size (MB): 40.66\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from torchsummary import summary\n",
    "summary(model, input_size=(12,signal_length), device='cpu')\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "012224f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create dataloaders\n",
    "resize_len = None if sampling_freq*10 == signal_length else signal_length\n",
    "loader_train = create_PTBXL_dataloader(sampling_freq, task, 'train', batch_size=batch_size, resize_len=resize_len)\n",
    "loader_val = create_PTBXL_dataloader(sampling_freq, task, 'val', batch_size=batch_size, resize_len=resize_len)\n",
    "loader_test = create_PTBXL_dataloader(sampling_freq, task, 'test', batch_size=batch_size, resize_len=resize_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "5911482b",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6ff86c40",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create output folder\n",
    "experiment_folder = os.path.join(output_folder, experiment_id)\n",
    "helper.check_create_folder(experiment_folder)\n",
    "\n",
    "# save model weights\n",
    "torch.save(model.state_dict(), os.path.join(experiment_folder, 'initial_weights.pth'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "2f3e9020",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../myoutput/20250602_01_inception_manual\n"
     ]
    }
   ],
   "source": [
    "print(experiment_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "4f522425",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to save checkpoint\n",
    "def save_checkpoint(state, filename, folder_path=os.path.join(experiment_folder, 'checkpoints')):\n",
    "\thelper.check_create_folder(folder_path)\n",
    "\ttorch.save(state, os.path.join(folder_path, filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "4f8899a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.20batch/s, avg_train_loss=0.402]\n",
      "1/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.65batch/s, \t\tavg_val_loss=0.309]\n",
      "2/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.21batch/s, avg_train_loss=0.313]\n",
      "2/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.57batch/s, \t\tavg_val_loss=0.305]\n",
      "3/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.22batch/s, avg_train_loss=0.292]\n",
      "3/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.73batch/s, \t\tavg_val_loss=0.291]\n",
      "4/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.24batch/s, avg_train_loss=0.284]\n",
      "4/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.64batch/s, \t\tavg_val_loss=0.283]\n",
      "5/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.23batch/s, avg_train_loss=0.277]\n",
      "5/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.54batch/s, \t\tavg_val_loss=0.275]\n",
      "6/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.271]\n",
      "6/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.86batch/s, \t\tavg_val_loss=0.277]\n",
      "7/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.26batch/s, avg_train_loss=0.267]\n",
      "7/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.83batch/s, \t\tavg_val_loss=0.281]\n",
      "8/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.262]\n",
      "8/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.74batch/s, \t\tavg_val_loss=0.274]\n",
      "9/50 [Train]: 100%|██████████| 535/535 [01:42<00:00,  5.24batch/s, avg_train_loss=0.259]\n",
      "9/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.73batch/s, \t\tavg_val_loss=0.274]\n",
      "10/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.256]\n",
      "10/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.78batch/s, \t\tavg_val_loss=0.271]\n",
      "11/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.251]\n",
      "11/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.69batch/s, \t\tavg_val_loss=0.283]\n",
      "12/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.26batch/s, avg_train_loss=0.248]\n",
      "12/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.68batch/s, \t\tavg_val_loss=0.271]\n",
      "13/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.244]\n",
      "13/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.78batch/s, \t\tavg_val_loss=0.273]\n",
      "14/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.26batch/s, avg_train_loss=0.242]\n",
      "14/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.74batch/s, \t\tavg_val_loss=0.268]\n",
      "15/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.27batch/s, avg_train_loss=0.239]\n",
      "15/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.80batch/s, \t\tavg_val_loss=0.275]\n",
      "16/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.235]\n",
      "16/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.75batch/s, \t\tavg_val_loss=0.271]\n",
      "17/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.26batch/s, avg_train_loss=0.231]\n",
      "17/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.81batch/s, \t\tavg_val_loss=0.271]\n",
      "18/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.25batch/s, avg_train_loss=0.229]\n",
      "18/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.82batch/s, \t\tavg_val_loss=0.271]\n",
      "19/50 [Train]: 100%|██████████| 535/535 [01:41<00:00,  5.27batch/s, avg_train_loss=0.224]\n",
      "19/50 [Val]  : 100%|██████████| 68/68 [00:03<00:00, 20.71batch/s, \t\tavg_val_loss=0.27] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stopping triggered\n"
     ]
    }
   ],
   "source": [
    "# training loop\n",
    "\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "\n",
    "best_val_loss = float('inf')\n",
    "patience = 5\n",
    "patience_counter = 0\n",
    "best_model_path = os.path.join(experiment_folder, 'best_model.pth')\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "\t# training\n",
    "\tmodel.train()\n",
    "\ttrain_loss = 0.0\n",
    "\n",
    "\tloader_train_tqdm = tqdm(loader_train, desc=f'{epoch+1}/{num_epochs} [Train]', leave=True, unit='batch')\n",
    "\n",
    "\tfor i, batch in enumerate(loader_train_tqdm):\n",
    "\t\tinputs, labels = [x.to(device, non_blocking=True) for x in batch]\n",
    "\n",
    "\t\toptimizer.zero_grad()\n",
    "\t\toutputs = model(inputs)\n",
    "\t\tloss = criterion(outputs, labels)\n",
    "\t\twith torch.autograd.set_detect_anomaly(True):\n",
    "\t\t\tloss.backward()\n",
    "\t\toptimizer.step()\n",
    "\n",
    "\t\ttrain_loss += loss.item()\n",
    "\t\tloader_train_tqdm.set_postfix({'avg_train_loss':train_loss/(i+1)})\n",
    "\n",
    "\tavg_train_loss = train_loss / len(loader_train)\n",
    "\ttrain_losses.append(avg_train_loss)\n",
    "\n",
    "\t# validation\n",
    "\tmodel.eval()\n",
    "\tval_loss = 0.0\n",
    "\tloader_val_tqdm = tqdm(loader_val, desc=f'{epoch+1}/{num_epochs} [Val]  ', leave=True, unit='batch')\n",
    "\twith torch.no_grad():\n",
    "\t\tfor i, batch in enumerate(loader_val_tqdm):\n",
    "\t\t\tinputs, labels = [x.to(device) for x in batch]\n",
    "\n",
    "\t\t\toutputs = model(inputs)\n",
    "\t\t\tloss = criterion(outputs, labels)\n",
    "\t\t\tval_loss += loss.item()\n",
    "\t\t\tloader_val_tqdm.set_postfix({'\\t\\tavg_val_loss':val_loss/(i+1)})\n",
    "\n",
    "\tavg_val_loss = val_loss / len(loader_val)\n",
    "\tval_losses.append(avg_val_loss)\n",
    "\n",
    "\t# save checkpoint every epoch\n",
    "\tcheckpoint = {\n",
    "\t\t'epoch': epoch,\n",
    "\t\t'model_state_dict': model.state_dict(),\n",
    "\t\t'optimizer_state_dict': optimizer.state_dict(),\n",
    "\t\t'train_loss': avg_train_loss,\n",
    "\t\t'val_loss': avg_val_loss\n",
    "\t}\n",
    "\tsave_checkpoint(checkpoint, f'epoch_{epoch+1}')\n",
    "\n",
    "\t# early stopping check\n",
    "\tif avg_val_loss < best_val_loss:\n",
    "\t\tbest_val_loss = avg_val_loss\n",
    "\t\tpatience_counter = 0\n",
    "\t\ttorch.save(model.state_dict(), best_model_path)\n",
    "\telse:\n",
    "\t\tpatience_counter += 1\n",
    "\tif patience_counter >= patience:\n",
    "\t\tprint('Early stopping triggered')\n",
    "\t\tbreak\n",
    "\n",
    "\t# tqdm.write(f\"train loss: {avg_train_loss:.4f} | val loss: {avg_val_loss:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "5f973849",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs = range(len(val_losses))\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(epochs, train_losses, label='train loss', marker='o')\n",
    "plt.plot(epochs, val_losses, label='val loss', marker='x')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.ylim(0, 1)\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2ba8e262",
   "metadata": {},
   "outputs": [],
   "source": [
    "# save model weights\n",
    "torch.save(model.state_dict(), os.path.join(experiment_folder, 'weights.pth'))\n",
    "\n",
    "# save experiment classes\n",
    "classes = loader_train.dataset.classes\n",
    "np.save(os.path.join(experiment_folder, 'classes.npy'), classes)\n",
    "\n",
    "# save training result\n",
    "training_result = pd.DataFrame({\n",
    "\t'train_loss':train_losses,\n",
    "\t'val_loss':val_losses\n",
    "})\n",
    "training_result.to_csv(os.path.join(experiment_folder, 'training_result.csv'), index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de295361",
   "metadata": {},
   "source": [
    "### Evaluate the best model\n",
    "\n",
    "We reload the best model and run it over test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2ded0f58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Inception1d(\n",
       "  (layers): Sequential(\n",
       "    (0): InceptionBackbone(\n",
       "      (im): ModuleList(\n",
       "        (0): InceptionBlock1d(\n",
       "          (bottleneck): Conv1d(12, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          (convs): ModuleList(\n",
       "            (0): Conv1d(32, 32, kernel_size=(39,), stride=(1,), padding=(19,), bias=False)\n",
       "            (1): Conv1d(32, 32, kernel_size=(19,), stride=(1,), padding=(9,), bias=False)\n",
       "            (2): Conv1d(32, 32, kernel_size=(9,), stride=(1,), padding=(4,), bias=False)\n",
       "          )\n",
       "          (conv_bottle): Sequential(\n",
       "            (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "            (1): Conv1d(12, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          )\n",
       "          (bn_relu): Sequential(\n",
       "            (0): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "            (1): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (1-5): 5 x InceptionBlock1d(\n",
       "          (bottleneck): Conv1d(128, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          (convs): ModuleList(\n",
       "            (0): Conv1d(32, 32, kernel_size=(39,), stride=(1,), padding=(19,), bias=False)\n",
       "            (1): Conv1d(32, 32, kernel_size=(19,), stride=(1,), padding=(9,), bias=False)\n",
       "            (2): Conv1d(32, 32, kernel_size=(9,), stride=(1,), padding=(4,), bias=False)\n",
       "          )\n",
       "          (conv_bottle): Sequential(\n",
       "            (0): MaxPool1d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
       "            (1): Conv1d(128, 32, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          )\n",
       "          (bn_relu): Sequential(\n",
       "            (0): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "            (1): ReLU()\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "      (sk): ModuleList(\n",
       "        (0): Shortcut1d(\n",
       "          (act_fn): ReLU(inplace=True)\n",
       "          (conv): Conv1d(12, 128, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          (bn): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Shortcut1d(\n",
       "          (act_fn): ReLU(inplace=True)\n",
       "          (conv): Conv1d(128, 128, kernel_size=(1,), stride=(1,), bias=False)\n",
       "          (bn): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (1): Sequential(\n",
       "      (0): AdaptiveConcatPool1d(\n",
       "        (ap): AdaptiveAvgPool1d(output_size=1)\n",
       "        (mp): AdaptiveMaxPool1d(output_size=1)\n",
       "      )\n",
       "      (1): Flatten()\n",
       "      (2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (3): Dropout(p=0.25, inplace=False)\n",
       "      (4): Linear(in_features=256, out_features=128, bias=True)\n",
       "      (5): ReLU(inplace=True)\n",
       "      (6): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (7): Dropout(p=0.5, inplace=False)\n",
       "      (8): Linear(in_features=128, out_features=5, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load best model\n",
    "trained_model = model\n",
    "trained_model.load_state_dict(torch.load(best_model_path))\n",
    "trained_model.to(device)\n",
    "trained_model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "17383973",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_labels = []\n",
    "all_preds = []\n",
    "result_folder = os.path.join(experiment_folder, 'result')\n",
    "helper.check_create_folder(result_folder)\n",
    "\n",
    "with torch.no_grad():\n",
    "\tfor inputs, labels in loader_test:\n",
    "\t\tinputs = inputs.to(device)\n",
    "\t\toutputs = trained_model(inputs)\n",
    "\t\tpreds = torch.sigmoid(outputs)\n",
    "\n",
    "\t\tall_labels.append(labels.cpu().numpy())\n",
    "\t\tall_preds.append(preds.cpu().numpy())\n",
    "\n",
    "y_test_true = np.concatenate(all_labels)\n",
    "y_test_pred = np.concatenate(all_preds)\n",
    "\n",
    "# save true and preds\n",
    "np.save(os.path.join(result_folder, 'y_test_true.npy'), y_test_true)\n",
    "np.save(os.path.join(result_folder, 'y_test_pred.npy'), y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "50f24ed5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC AUC score: 0.9288267470166094\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reload predictions\n",
    "y_test_true = np.load(os.path.join(result_folder, 'y_test_true.npy'))\n",
    "y_test_pred = np.load(os.path.join(result_folder, 'y_test_pred.npy'))\n",
    "\n",
    "# reload class names\n",
    "classes = np.load(os.path.join(experiment_folder, 'classes.npy'), allow_pickle=True)\n",
    "\n",
    "score = None\n",
    "if task_type == 'multilabel':\n",
    "\tscore = roc_auc_score(y_test_true, y_test_pred, average='macro')\n",
    "elif task_type == 'binary':\n",
    "\tscore = roc_auc_score(y_test_true, y_test_pred)\n",
    "\n",
    "print(f'ROC AUC score: {score}')\n",
    "\n",
    "# plot ROC curve\n",
    "if task_type == 'multilabel':\n",
    "\tn_classes = y_test_pred.shape[1]\n",
    "\tplt.figure(figsize=(10,8))\n",
    "\tplt.grid(True)\n",
    "\tplt.xlabel('false positive rate')\n",
    "\tplt.ylabel('true positive rate')\n",
    "\tfor i in range(n_classes):\n",
    "\t\tfpr, tpr, _ = roc_curve(y_test_true[:, i], y_test_pred[:,i])\n",
    "\n",
    "\t\tplt.plot(fpr, tpr, label=f'Class {i} ({classes[i]})')\n",
    "\t\n",
    "\tplt.legend(loc='lower right')\n",
    "\tplt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ecg_env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
